# -*- coding: utf-8 -*-
# @Time    : 2021/4/17 12:39
# @Author  : mokez
# @Email   : mokez@qq.com
# @File    : 19道题作业.py
# @Software: PyCharm
# 1、密码验证
# 2、列表去重并从大到小排序  https://www.imooc.com/article/50585
# lst = [10, 5, 3, 2, 0, 7, 5, 4, 7]
# lst1 = list(set(lst))[::-1]
# print(lst1)
# 3、如何在一个函数内部修改全局变量
# 重新赋值

# 4、如何跨模块共享全局变量
# 除了函数内部，python的变量本身作用域就是全局的。
# 不同的模块互相导入时，将变量一同导入就行了，而函数内修改这些全局变量时需要先用global修饰变量名。

# 5、python数据类型有哪些
# 数字，字符串，列表，元组，字典，集合

# 6、python中生成随机整数（1-10），随机小数（1-10），0-1之间小数的方法
# import random
# 随机整数（1-10）
# print(random.randint(1,10))
# 随机小数（1-10）
# print(random.uniform(1,10))
# 0-1 之间小数的方法
# print(random.random())

# 7、python2与python3 的区别，列出5个
# python2是地板除，Python3不是
# 模块中的python2需要添加__init__.py,python3可加可不加
# 输入输出，python2 print可不用括号，input默认是int，字符串需要引号包裹；Python3需要括号，input默认是str
# 编码：Python2是ascii码，Python3 是utf-8
# 字符串拼接，python3可以用f标志位拼接
# python2 bool类型True和False没有定义成关键字，Python3中定义了


# 8、python中哪些是可变数据类型，哪些是不可变数据类型，为什么
# 列表是可变的，字典是可变的，集合是可变的
# 元组是不可变的，str，bool，int,float,数字，日期

# 9、统计字符串中每个单词出现的次数
# import string
# str="i am mokez, i am 20 years old"
#
# txt_line = str.translate(str.maketrans("", "", string.punctuation)).lower().split()
# dc = {}
# for word in txt_line:
#     if word in dc:
#         dc[word] += 1
#     else:
#         dc[word] = 1
# result = sorted(dc.items(), key=lambda dc: dc[1], reverse=True)
# # print(result)
# for i in result:
#     print(f"'{i[0]}':{i[1]}")

# 10、给定一个字符串，找到字符串中第一个重复的字符
# str="abciopabc"
#
# for i in range(0,len(str)):
#     if str[i] in str[i+1:]:
#         print(f"{str[i]}")
#         break
# 11、什么是pep8
#     是一种pyhton的一种编码规范
# 12、python里如何赋值，深拷贝与浅拷贝的区别
# a=3
# 内存会为3创建一个数据单元，再让a指向这个单元
# 深浅拷贝的区别
# 浅拷贝，只拷贝第一层
# 例如，
# import copy
# list_a=[1,2,[3,4]]
# print(list_a)
# list_b=copy.copy(list_a)
# print(list_b)
# # 对list_a添加一个数,list_a多了一个5,list_b不变
# list_a.append(5)
# print(list_a)
# print(list_b)
# # 对list_a中的[3,4]添加一个数,发现[3,4]改变了，说明浅拷贝只对第一层有效，更深一层的列表发生改变时，会使整个列表改变
# list_a[2].append(6)
# print(list_a)
# print(list_b)
# # 深拷贝
# list_c=[1,2,[3,4]]
# list_d=copy.deepcopy(list_c)
# print(list_c)
# print(list_d)
# # 对list_c添加一个数,list_c多了一个5,list_b不变
# list_c.append(5)
# print(list_c)
# print(list_d)
# # 对list_c中的[3,4]添加一个数，list_d不变,说明了深拷贝开辟了一个新的空间，将list_c,完全复制给list_d,不管对list_c进行什么操作，list_d是不受影响的
# list_c[2].append(6)
# print(list_c)
# print(list_d)
# https://blog.51cto.com/dzlly1/2335628

# 13、简述python的内存管理机制
# 分别是 引用计数机制，垃圾回收机制，内存池机制
# 引用计数机制：有个ob_ref字段,用来记录对象的引用计数，当有新的变量指向对象时，引用计数+1
# 引用失效时，ob_ref引用计数-1，
# 最主要的问题是不能解决循环引用
# 垃圾回收机制： 当引用计数为0时，可以被垃圾回收，三种情况会触发，调用gc.collect(),GC达到阈值时，程序退出时。
# 内存池机制：小内存使用内存池进行分配，[-5,256]的整数
#          大内存使用malloc进行分配
# 只含有字母数字的字符串自动触发缓存机制，使用字符串的intern机制
# https://www.cnblogs.com/geaozhang/p/7111961.html
#
# 14、使用python实现冒泡排序
a = [22, 7, 1, 3, 5, 98, 56]
for i in range(1,len(a)):
    for j in range(len(a) - i):
        if a[j] > a[j + 1]:
            a[j], a[j + 1] = a[j + 1], a[j]
print("===")
print(a)


# 15、使用python实现快速排序
def QuickSort(nums, left, right):
    if left >= right:
        return 0
    baseNumber = nums[left]
    i = left
    j = right
    while i != j:
        while j > i and nums[j] >= baseNumber:
            j -= 1
        if j > i:
            nums[i], nums[j] = nums[j], nums[i]

        while i < j and nums[i] <= baseNumber:
            i += 1
        if i < j:
            nums[i], nums[j] = nums[j], nums[i]
    QuickSort(nums, left, i - 1)
    QuickSort(nums, i + 1, right)

a = [22, 7, 1, 3, 5, 98, 56,44,33]
QuickSort(a, 0, len(a) - 1)
print(a)

# 16、输出九九乘法表
# for i in range(1,10):
#     for j in range(1,i+1):
#         print(f"{i}*{j}={i*j}",end=" ")
#     print()
# 17、重复接受用户的数据，如果是正整数就输出结果，否则一直输入
# while True:
#     try:
#         num = input("请输入一个正整数：")
#         if int(num)>0:
#             print(f"{num}是一个正整数")
#             break
#         else:
#             print("请重新输入")
#     except ValueError:
#         print("请输入一个正整数！")
# 18、有两个列表[11,-3,4,5,2,1,8] , [9,3,4,2,6,-10] 把它们合并成一个列表，并且从小到大排序
# list1 = [11,-3,4,5,2,1,8]
# list2 = [9,3,4,2,6,-10]
# print(sorted(list2+list1))
# 19、a+=1 与 a=a+1 有什么区别
# 对于可变对象，a += 1 直接在原内存地址上操作a = a + 1开辟新的内存操作
# 对于不可变对象，a += 1和a = a + 1都是在新开辟的空间操作
